/*
 * Alloy Analyzer
 * Copyright (c) 2002 Massachusetts Institute of Technology
 *
 * The Alloy Analyzer is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * The Alloy Analyzer is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with the Alloy Analyzer; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package alloy.ast;

/**
 * The interface for a visitor performing an operation on the AST.
 * Visitors which need to return a value from the visit method should
 * implement {@link ASTReturnVisitor}.
 */
public interface ASTVisitor {

    /** Visit a node of type {@link Node} */
    public void visit(Node node_);

    /** Visit a node of type {@link ArgList} */
    public void visit(ArgList argList_);

    /** Visit a node of type {@link SumIntExpr} */
    public void visit(SumIntExpr sumIntExpr_);

    /** Visit a node of type {@link ArrowMultExpr} */
    public void visit(ArrowMultExpr arrowMultExpr_);

    /** Visit a node of type {@link Assertion} */
    public void visit(Assertion assertion_);

    /** Visit a node of type {@link Assertions} */
    public void visit(Assertions assertions_);

    /** Visit a node of type {@link BinaryExpr} */
    public void visit(BinaryExpr binaryExpr_);

    /** Visit a node of type {@link BinaryExprOp} */
    public void visit(BinaryExprOp binaryExprOp_);

    /** Visit a node of type {@link BinaryFormula} */
    public void visit(BinaryFormula binaryFormula_);

    /** Visit a node of type {@link CardinalityExpr} */
    public void visit(CardinalityExpr cardinalityExpr_);

    /** Visit a node of type {@link CheckCommand} */
    public void visit(CheckCommand checkCommand_);

    /** Visit a node of type {@link Command} */
    public void visit(Command command_);

    /** Visit a node of type {@link Commands} */
    public void visit(Commands commands_);

    /** Visit a node of type {@link CompOp} */
    public void visit(CompOp compOp_);

    /** Visit a node of type {@link ComprehensionExpr} */
    public void visit(ComprehensionExpr comprehensionExpr_);

    /** Visit a node of type {@link DeclFormula} */
    public void visit(DeclFormula declFormula_);

    /** Visit a node of type {@link Decl} */
    public void visit(Decl decl_);

    /** Visit a node of type {@link Decls} */
    public void visit(Decls decls_);

    /** Visit a node of type {@link ElemFormula} */
    public void visit(ElemFormula elemFormula_);

    /** Visit a node of type {@link EmptySetExpr} */
    public void visit(EmptySetExpr emptySetExpr_);

    /** Visit a node of type {@link Expr} */
    public void visit(Expr expr_);

    /** Visit a node of type {@link Exprs} */
    public void visit(Exprs exprs_);

    /** Visit a node of type {@link Fact} */
    public void visit(Fact fact_);

    /** Visit a node of type {@link FindCommand} */
    public void visit(FindCommand findCommand_);

    /** Visit a node of type {@link Formula} */
    public void visit(Formula formula_);

    /** Visit a node of type {@link FormulaPara} */
    public void visit(FormulaPara formulaPara_);

    /** Visit a node of type {@link FormulaSeq} */
    public void visit(FormulaSeq formulaSeq_);

    /** Visit a node of type {@link Formulas} */
    public void visit(Formulas formulas_);

    /** Visit a node of type {@link Function} */
    public void visit(Function function_);

    /** Visit a node of type {@link Functions} */
    public void visit(Functions functions_);

    /** Visit a node of type {@link GeneralScope} */
    public void visit(GeneralScope generalScope_);

    /** Visit a node of type {@link Id} */
    public void visit(Id id_);

    /** Visit a node of type {@link Ids} */
    public void visit(Ids ids_);

    /** Visit a node of type {@link ImplicationFormula} */
    public void visit(ImplicationFormula implicationFormula_);

    /** Visit a node of type {@link InvocationExpr} */
    public void visit(InvocationExpr invocationExpr_);

    /** Visit a node of type {@link InvocationFormula} */
    public void visit(InvocationFormula invocationFormula_);

    /** Visit a node of type {@link SumExpr} */
    public void visit(SumExpr sumExpr_);

    /** Visit a node of type {@link LogicOp} */
    public void visit(LogicOp logicOp_);

    /** Visit a node of type {@link Module} */
    public void visit(Module module_);

    /** Visit a node of type {@link Modules} */
    public void visit(Modules modules_);

    /** Visit a node of type {@link MultiplicityExpr} */
    public void visit(MultiplicityExpr multiplicityExpr_);
    
    /** Visit a node of type {@link MultiplicityFormula} **/
    public void visit(MultiplicityFormula multFormula_);

    /** Visit a node of type {@link NegFormula} */
    public void visit(NegFormula negFormula_);

    /** Visit a node of type {@link Path} */
    public void visit(Path path_);

    /** Visit a node of type {@link Predicate} */
    public void visit(Predicate predicate_);

    /** Visit a node of type {@link Predicates} */
    public void visit(Predicates predicates_);

    /** Visit a node of type {@link Qualifier} */
    public void visit(Qualifier qualifier_);

    /** Visit a node of type {@link Qualifiers} */
    public void visit(Qualifiers qualifiers_);

    /** Visit a node of type {@link QuantifiedExpr} */
    public void visit(QuantifiedExpr quantifiedExpr_);

    /** Visit a node of type {@link QuantifiedFormula} */
    public void visit(QuantifiedFormula quantifiedFormula_);

    /** Visit a node of type {@link Quantifier} */
    public void visit(Quantifier quantifier_);

    /** Visit a node of type {@link RunCommand} */
    public void visit(RunCommand runCommand_);

    /** Visit a node of type {@link Scope} */
    public void visit(Scope scope_);

    /** Visit a node of type {@link SetMultExpr} */
    public void visit(SetMultExpr setMultExpr_);

    /** Visit a node of type {@link Multiplicity} */
    public void visit(Multiplicity multiplicity_);

    /** Visit a node of type {@link SigExpr} */
    public void visit(SigExpr sigExpr_);

    /** Visit a node of type {@link SigExprs} */
    public void visit(SigExprs sigExprs_);

    /** Visit a node of type {@link Signature} */
    public void visit(Signature signature_);

    /** Visit a node of type {@link Signatures} */
    public void visit(Signatures signatures_);

    /** Visit a node of type {@link Specification} */
    public void visit(Specification specification_);

    /** Visit a node of type {@link SpecificScope} */
    public void visit(SpecificScope specificScope_);

    /** Visit a node of type {@link TreeNode} */
    public void visit(TreeNode treeNode_);

    /** Visit a node of type {@link TypeScope} */
    public void visit(TypeScope typeScope_);

    /** Visit a node of type {@link TypeScopes} */
    public void visit(TypeScopes typeScopes_);

    /** Visit a node of type {@link UnaryExpr} */
    public void visit(UnaryExpr unaryExpr_);

    /** Visit a node of type {@link UnaryExprOp} */
    public void visit(UnaryExprOp unaryExprOp_);

    /** Visit a node of type {@link VariableExpr} */
    public void visit(VariableExpr variableExpr_);

    /** Visit a node of type {@link Variable} */
    public void visit(Variable variable_);

    /** Visit a node of type {@link Variables} */
    public void visit(Variables variables_);

    /** Visit a node of type {@link TypedExpr} */
    public void visit(TypedExpr typedExpr_);

    /** Visit a node of type {@link IntExpr} */
    public void visit(IntExpr intExpr_);

    /** Visit a node of type {@link Facts} */
    public void visit(Facts facts_);

    /** Visit a node of type {@link BinaryIntExpr} */
    public void visit(BinaryIntExpr binaryIntExpr_);

    /** Visit a node of type {@link IntCompOp} */
    public void visit(IntCompOp intCompOp_);

    /** Visit a node of type {@link IntExprOp} */
    public void visit(IntExprOp intExprOp_);

    /** Visit a node of type {@link EmptyFormula} */
    public void visit(EmptyFormula emptyFormula_);

    /** Visit a node of type {@link IntNode} */
    public void visit(IntNode intNode_);

    /** Visit a node of type {@link EmptyExpr} */
    public void visit(EmptyExpr emptyExpr_);

    /** Visit a node of type {@link QualifiedName} */
    public void visit(QualifiedName qualifiedName_);

    /** Visit a node of type {@link LiteralIntExpr} */
    public void visit(LiteralIntExpr literalIntExpr_);

    /** Visit a node of type {@link ElemIntFormula} */
    public void visit(ElemIntFormula elemIntFormula_);

    /** Visit a node of type {@link Paragraph} */
    public void visit(Paragraph paragraph_);

    /** Visit a node of type {@link Paragraphs} */
    public void visit(Paragraphs paragraphs_);

    /** Visit a node of type {@link IntExprCastExpr} */
    public void visit(IntExprCastExpr intExprCastExpr_);

    /** Visit a node of type {@link ExprCastIntExpr} */
    public void visit(ExprCastIntExpr exprCastIntExpr_);

    /** Visit a node of type {@link GenericConstExpr} */
    public void visit(GenericConstExpr genericConstExpr_);

    /** Visit a node of type {@link UniversalExpr} */
    public void visit(UniversalExpr universalExpr_);

    /** Visit a node of type {@link IdentityExpr} */
    public void visit(IdentityExpr identityExpr_);

    /** Visit a node of type {@link IfThenElseExpr} */
    public void visit(IfThenElseExpr ifThenElseExpr_);

    /** Visit a node of type {@link IfThenElseIntExpr} */
    public void visit(IfThenElseIntExpr ifThenElseIntExpr_);

    /** Visit a node of type {@link LetDecl} */
    public void visit(LetDecl letDecl_);

    /** Visit a node of type {@link LetDecls} */
    public void visit(LetDecls letDecls_);

    /** Visit a node of type {@link LetImpl} */
    public void visit(LetImpl letImpl_);

    /** Visit a node of type {@link LetExpr} */
    public void visit(LetExpr letExpr_);

    /** Visit a node of type {@link LetFormula} */
    public void visit(LetFormula letFormula_);

    /** Visit a node of type {@link LetIntExpr} */
    public void visit(LetIntExpr letIntExpr_);

    /** Visit a node of type {@link SigmaExpr} */
    public void visit(SigmaExpr sigmaExpr_);

}





